home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / pm-utils / functions < prev    next >
Encoding:
Text File  |  2009-10-06  |  5.3 KB  |  249 lines
  1. #!/bin/sh
  2. # vim:noexpandtab
  3.  
  4. # Common functionality for the hooks.
  5.  
  6. # for great debugging!
  7. [ "${PM_DEBUG}" = "true" ] && set -x
  8.  
  9. # try to take the lock.  Fail if we cannot get it.
  10. try_lock()
  11. {
  12.     # $1 = file to use as lockfile
  13.     # $2 (optional) content to write to the lockfile,
  14.     # extra newline will be appended
  15.     # make sure the directory where the lockfile should be exists
  16.     mkdir -p "${LOCKDIR}"
  17.     local lock="${LOCKDIR}/${1##*/}"
  18.     # we use noclobber to make sure there are no race conditions
  19.     (set -o noclobber; echo "${2}" > "${lock}") 2> /dev/null || return 1
  20.     return 0
  21. }
  22.  
  23. # spin waiting for the lock with optional timeout.  
  24. # return once we have it, or the timeout has expired
  25. spin_lock()
  26. {
  27.     # $1 = lockfile
  28.     # $2 = optional timeout
  29.     local elapsed=0
  30.     while ! try_lock $1; do
  31.         [ "x$2" != "x" ] && [ $(( $elapsed == $2 )) -ne 0 ] && return 1
  32.         elapsed=$(($elapsed + 1))
  33.         sleep 1;
  34.     done
  35. }
  36.  
  37. # release the lock
  38. release_lock()
  39. {
  40.     # $1 = lockfile
  41.     local lock="${LOCKDIR}/${1##*/}"
  42.     rm -f "${lock}"
  43.     return $?
  44. }
  45.  
  46. command_exists()
  47. {
  48.     # $1 = command to test for.  It can be an executable in the path,
  49.     # a shell function, or a shell builtin.
  50.     type "$1" >/dev/null 2>&1
  51.     return $?
  52. }
  53.  
  54. get_power_status()
  55. {
  56.     on_ac_power
  57.     case "$?" in
  58.         "0")    echo "ac" ;;
  59.         "1")    echo "battery" ;;
  60.         "255")  echo "error"
  61.             return 1
  62.             ;;
  63.     esac
  64.     return 0
  65. }
  66.  
  67. # TODO: Module loading and unloading is Linux-specific.  
  68. # Look into modularizing this into an os-specific set of support routines.
  69. _rmmod()
  70. {
  71.     if modprobe -r "$1"; then
  72.         touch "${STORAGEDIR}/module:$1"
  73.         return 0
  74.     else
  75.         log "# could not unload '$1', usage count was $2"
  76.         return 1
  77.     fi
  78. }
  79.  
  80. # this recursively unloads the given modules and all that depend on it
  81. # first parameter is the module to be unloaded
  82. modunload()
  83. {
  84.     local MOD D C USED MODS I
  85.     local UNL="$(echo $1 |tr - _)" RET=1 
  86.  
  87.     while read MOD D C USED D; do
  88.         [ "$MOD" = "$UNL" ] || continue
  89.         if [ "$USED" = "-" ]; then
  90.             # no dependent modules, just try to remove this one.
  91.             _rmmod "$MOD" $C
  92.             RET=$?
  93.         else
  94.             # modules depend on this one.  try to remove them first.
  95.             MODS=",${USED%,}"
  96.             while [ -n "${MODS}" ]; do
  97.                 # try to unload the last one first
  98.                 MOD="${MODS##*,}"
  99.                 modunload $MOD && RET=0
  100.                 # prune the last one from the list
  101.                 MODS="${MODS%,*}"
  102.             done
  103.             # if we unloaded at least one module, then let's
  104.             # try again!
  105.             [ $RET -eq 0 ] && modunload $MOD
  106.             RET=$?
  107.         fi
  108.         return $RET
  109.     done < /proc/modules
  110.     # if we came this far, there was nothing to do, 
  111.     # the module is no longer loaded.
  112.     return 0
  113. }
  114.  
  115. # reload all the modules in no particular order.
  116. # modprobe should take care of loading prerequisites for us.
  117. modreload()
  118. {
  119.     for x in "${STORAGEDIR}"/module:* ; do
  120.         [ -O "${x}" ] || continue
  121.         modprobe -b "${x##*:}" >/dev/null 2>&1 || \
  122.             log "Could not reload module ${x##*:}."
  123.  
  124.     done
  125. }
  126.  
  127. # Service management is sysv dependent.
  128. # TODO: modularize this to make it work with other init systems.
  129. if ! command_exists service; then
  130.     service()
  131.     {
  132.         for svc in "/etc/init.d/$1" "/etc/rc.d/rc.$1"; do #lsb, then slack
  133.         [ -x "$svc" ] && { shift; "$svc" "$@"; return $?; }
  134.             done
  135.             # this only happens if we did not find the service
  136.             log "${1}: unrecognized service"
  137.             return 1
  138.         
  139.     }
  140. fi
  141.  
  142. stopservice()
  143. {
  144.     if [ -x "/etc/init.d/$1" ]
  145.     then
  146.         touch "${STORAGEDIR}/service:$1"
  147.         invoke-rc.d "$1" stop
  148.     fi
  149. }
  150.  
  151. restartservice()
  152. {
  153.     [ -O "${STORAGEDIR}/service:$1" ] && invoke-rc.d "$1" start
  154. }
  155.  
  156. # Disable a hook.
  157. disablehook()
  158. {
  159.     # $1 = name of hook to disable.
  160.     # $2 = optional comment.
  161.     echo "${2:-${0##*/}}" > "${STORAGEDIR}/disable_hook:${1##*/}"
  162. }
  163.  
  164. # Save an arbitrary piece of state for later use.
  165. # If called with just one argument, it reads stdin and saves it to a file.
  166. # If called with 2 arguments, it saves $2 to a file.
  167. savestate()
  168. {
  169.     # $1 = name of state to save
  170.     # $2 (optional) State to save.  If omitted, save stdin.
  171.     if [ -n "$2" ]; then
  172.         echo "$2" > "${STORAGEDIR}/state:$1"
  173.     else
  174.         cat > "${STORAGEDIR}/state:$1"
  175.     fi
  176. }
  177.  
  178. # Check to see of a piece of state exists.
  179. state_exists()
  180. {
  181.     # $1 = name of state
  182.     [ -O "${STORAGEDIR}/state:$1" ]
  183. }
  184.  
  185. # Output previously saved state to stdout.
  186. restorestate()
  187. {
  188.     # $1 = name of state
  189.     state_exists "$1" && cat "${STORAGEDIR}/state:$1"
  190. }
  191.  
  192. # Inhibit suspend/resume and running any more hooks.
  193. # Any parameters passed ti this function will be saved in the inhibit file.
  194. inhibit()
  195. {
  196.     echo "$*" > "$INHIBIT"
  197. }
  198.  
  199. # Are we inhibited?
  200. inhibited()
  201. {
  202.     [ -f "$INHIBIT" ]
  203. }
  204.  
  205. # If we were told by the user to ignore some parameters from HAL.
  206. # remove parameters from our list
  207. remove_parameters() {
  208.     local p
  209.     if [ "$1" = "all" ]; then
  210.         echo '' > "$PARAMETERS.new"
  211.     else
  212.         echo '' >"$PARAMETERS.rm"
  213.         for p in "$@"; do
  214.         echo "$p" >> "$PARAMETERS.rm"
  215.         done
  216.         # let grep do the dirty work.
  217.         grep -vxFf "$PARAMETERS.rm" "$PARAMETERS" > "$PARAMETERS.new"
  218.     fi
  219.     cp -f "$PARAMETERS.new" "$PARAMETERS"
  220. }
  221.  
  222. # Add a parameter to our commandline parameters. 
  223. add_parameters() {
  224.     remove_parameters "$@" # no dups, please.
  225.     for x in "$@"; do
  226.         echo "$x" >>"$PARAMETERS"
  227.     done
  228. }
  229.  
  230. # Get our commandline parameters
  231. get_parameters() {
  232.        cat "$PARAMETERS"
  233. }
  234.  
  235. # check to see if a single parameter exists
  236. has_parameter()
  237. {
  238.     for p in $(get_parameters); do
  239.         [ "$p" = "$1" ] && return 0
  240.     done
  241.     return 1
  242. }
  243.  
  244. # Like regular dbus-send, but returns $NA if the command fails for any reason.
  245. dbus_send ()
  246. {
  247.     command dbus-send "$@" 2>/dev/null || return $NA
  248. }
  249.